Ext.ns('MyExt');
Ext.ns('MyExt', 'MyExt.util');
Ext.ns('MyExt', 'MyExt.form');
Ext.ns('MyExt', 'MyExt.grid');
Ext.ns('MyExt', 'MyExt.tree');
Ext.ns('MyExt', 'MyExt.plugin');


MyExt.util.changeIsReadOnly = function(form,array,boolean,action){
	for(var i = 0, len = array.length; i < len; i++){
                var f = form.findField(array[i].name);
                var addIsShow = array[i].addIsShow;
                var editIsReadOnly = array[i].editIsReadOnly;
                var editIsShow = array[i].editIsShow;
                
                if(f){
			        if(action=="add"){   //如果是增加
				        	
				        	if(addIsShow==true||Ext.isEmpty(addIsShow)){   //如果是该字段要显示
				        		f.show();
				        		f.removeClass("x-item-disabled");
				        		f.getEl().up('.x-form-item').setDisplayed(true); 
				        	}else if(addIsShow==false){ 				//如果不需要显示
				        		f.hide();                   
				        		f.getEl().up('.x-form-item').setDisplayed(false); //隐藏序号id
				        		f.addClass("x-item-disabled");
				        	}
				        	
				        	if(f.rendered){
					           f.el.dom.readOnly = false;
					           //f.el.dom.style.background = "#E5E5E5";
					        }else{
					       	 	f.readOnly = false;
					        }
					        
			         }else if (action=="edit"){		//如果是修改
			          		if(editIsReadOnly == true){
			          				f.show();
			          				f.getEl().up('.x-form-item').setDisplayed(true); //隐藏序号id
			          				f.addClass("x-item-disabled");
				          			if(f.rendered){
							           f.el.dom.readOnly = true;
							        }else{
							       	 	f.readOnly = true;
							        }
							        
			          		}else{
			          				f.removeClass("x-item-disabled");
			          				f.show();
			          				if(f.rendered){
							           f.el.dom.readOnly = false;
							        }else{
							       	 	f.readOnly = false;
							        }
							        
			          		}
			          		
			          		if( editIsShow == true ){
			          				f.show();
			          				f.removeClass("x-item-disabled");
			          				f.getEl().up('.x-form-item').setDisplayed(true); //隐藏序号id
			          				if(f.rendered){
							           f.el.dom.readOnly = false;
							        }else{
							       	 	f.readOnly = false;
							        }
			          			
			          		}else if( Ext.isEmpty(editIsReadOnly) && editIsShow==false ){
			          			f.getEl().up('.x-form-item').setDisplayed(false); //隐藏序号id
			          			f.hide();
			          		}
			          		
			          	}	
			          
			          
			         } //if结束
			  
    }//for循环结束
}


/**
 * 
 * @class MyExt.plugin.FieldTips
 * @extends Ext.util.Observable
 * Form悬浮提示框插件
 */
MyExt.plugin.FieldTips = Ext.extend(Ext.util.Observable, {
	
	init : function(form)
	{
		this.form = form;
		form.on('render', this.initTips, this);
	},
	
	initTips : function()
	{
		/**
		 * 如果表单元素没有设置tipMsg属性则不生成悬浮提示框
		 * 如果组件类型为fieldset则遍历所有子元素
		 */
		this.form.items.each(function(field){
			
			if(field.xtype == "fieldset")
			{
				field.items.each(function(item){
					
					if(item.tipMsg)
					{
						this.createTips(item);
					}
				}, this);
			}
			else if(field.tipMsg)
			{
				this.createTips(field);
			}
        }, this);

	},
	
	createTips : function(field)
	{
		field.on("render",function(){
				field.tips = new Ext.ToolTip({
					target:field.id,
					anchor:'left',
					showDelay:0,
			        dismissDelay:0,
			        trackMouse: true,
			        autoDestroy : true,
			        renderTo: document.body,
					html:'<b>'+field.tipMsg+'</b>'
				});
		});
		
		field.on("destroy",function(){
			field.tips.destroy();
		})
		//field.el.on('focus', this.showTips, this, tips);
	}
});


/**
 * 
 * @class MyExt.FormPanel
 * @extends Ext.FormPanel
 */

MyExt.FormPanel = Ext.extend(Ext.FormPanel, {
	/**
	 * 是否显示标题栏，默认为不显示
	 */
	header: false,
	frame : true,
	/**
	 * 
	 * 默认允许自动滚动条
	 */
	autoScroll : true,
	/**
	 * 组件标签和内容之间的分隔符默认为冒号：
	 */
	labelSeparator : ':',
	/**
	 * 
	 * 表单组件默认标签宽度为100
	 */
	labelWidth : 100,
	/**
	 * 
	 * 表单组件默认标签右对齐
	 */
	labelAlign : 'left',
	labelPad : 20,
	/**
	 * 
	 * 按钮对齐方式，默认为居中
	 */
	buttonAlign : 'center',
	
	bodyStyle: 'padding:10px;',
	/**
	 * 非column布局下，表单内组件占用全部宽度的百分比默认为70%
	 * 
	 */
	defaults : {anchor:'70%'},
	/**
	 * 
	 * 悬浮在表单组件上是否显示字数限制等提示信息，默认如果该组件设置了tipMsg属性则显示，否则不显示
	 */
	fieldTips : true,
	/**
	 * 是否采用传统提交方式，默认为采用AJAX方式提交 
	 */
	standardSubmit : false,
	
	initComponent : function()
	{
		/**
		 * 初始化tips
		 */
		if(!Ext.QuickTips.isEnabled())
		{
			Ext.QuickTips.init();
		}
		
		this.height = this.height||Ext.getBody().getComputedHeight();
		
		if(this.fieldTips)
		{
		
			this.plugins = this.plugins||[];
			this.plugins.push(new MyExt.plugin.FieldTips());
		}
		
		/**
		 * 如果使用列布局，则每列元素默认使用form布局
		 */
		if(this.layout == "column")
		{
			this.defaults = {
				layout : 'form'
			};
		}
		else
		{
			/**
			 * 
			 * 表单组件默认元素xtype为文本框
			 */
			this.defaultType = 'textfield';
		}
		
	    MyExt.FormPanel.superclass.initComponent.call(this);
	},
	
	afterRender : function()
	{
		MyExt.FormPanel.superclass.afterRender.call(this);
		 
	    if(Ext.isIE)
	    {
	    	this.setWidth(!Ext.getBody().isScrollable()?Ext.getBody().getComputedWidth():Ext.getBody().getComputedWidth()-Ext.getScrollBarWidth());
	    }
	},
	
	submit : function(subCfg)
	{
		this.getForm().submit(subCfg);
	},
	
	reset : function()
	{
		this.getForm().reset();
	},
	
	findField : function(id)
	{
		return this.getForm().findField(id);
	},
	
	/**
	 * @param id form表单内部的组件id
	 * @return 该组件的当前值
	 */
	getValue : function(id)
	{
		var field = this.findField(id);
		
		if(field.xtype == "radiogroup")
		{
			return field.getValue().getGroupValue();
		}
		if(field.xtype == "MyExtdatefield")
		{
			return field.getFormatValue();
		}
		return field.getValue();
	},
	/**
	 * @param asString 为真时返回字符串，为假时返回对象
	 * @return 返回id:value形式的所有表单组件的值
	 */
	getValues : function(asString)
	{
		return this.getForm().getValues(asString);
	},
	
	getFieldValues : function(dirtyOnly)
	{
		return this.getForm().getFieldValues(dirtyOnly);
	},
	
	isValid : function()
	{
		return this.getForm().isValid();
	},
	
	clearInvalid : function()
	{
		this.getForm().clearInvalid();
	}
});

Ext.reg('MyExtform', MyExt.FormPanel);

MyExt.form.FormPanel = MyExt.FormPanel;



/**
 * 
 * @class MyExt.form.ComboBox
 * @extends Ext.form.ComboBox
 * 下拉框组件 默认读取本地数据 延迟初始化 可悬浮提示选项内容
 */
MyExt.form.ComboBox = Ext.extend(Ext.form.ComboBox, {
	/**
	 * 数据读取模式，默认为本地local，远程为remote
	 */
	mode : 'local',
	/**
	 * 不允许直接在下拉框中编辑并输入，只能选择下拉框中已存在的值
	 */
	editable : true,
	/**
	 * 延迟初始化下拉列表，直到第一次获得焦点 
	 */
	lazyInit : true,
	/**
	 *只能选择下拉框中的值，不允许设置除此之外的值 
	 */
	forceSelection : true,
	/**
	 * 当选择一个项时，使用的查询字符串，默认为返回全部记录
	 */
	triggerAction : 'all',
	/**
	 * 自动滚动条
	 */
	autoScroll : true,
	/**
	 * 下拉列表最大高度，默认为300
	 */
	maxHeight : 300,
	/**
	 * 默认下拉框不允许为空
	 */
	allowBlank : true,
	/**
	 * 校验信息显示的位置，默认为组件右部
	 */
	msgTarget : 'side',
	/**
	 * 悬浮在选项上时是否显示提示，当宽度不够时使用，默认不使用
	 */
	hoverTips : false,
	
	
	initComponent : function()
	{
		if(this.hoverTips)
		{
			this.tpl = '<tpl for="."><div ext:qtip="{' + this.displayField + '}" class="x-combo-list-item">{' + this.displayField + '}</div></tpl>';
		}
		
		MyExt.form.ComboBox.superclass.initComponent.call(this);
		/**
		 *  下拉框框提交时需要用到hiddenName这个属性才能在服务器端获取选中的值，否则提交的为显示的值。
		 *  设置提交时所用到的hiddenName，如果下拉框设置了name则与name相同，否则与id相同
		 */
		if(!this.hiddenName)
		{
			this.hiddenName = this.name||this.id;
		}
	},
	
	onLoad : function()
	{
		MyExt.form.ComboBox.superclass.onLoad.call(this);
		
		if(this.value && this.selectedIndex == -1){
			this.setValue(this.value);
		}
	}
});

Ext.reg('MyExtcombo', MyExt.form.ComboBox);




/**
 * 
 * @class MyExt.form.DateField
 * @extends Ext.form.DateField
 */
MyExt.form.DateField = Ext.extend(Ext.form.DateField, {
	/**
	 * 不允许直接在日期框中编辑并输入，只能根据下拉日立来选择
	 */
	editable : false,
	/**
	 * 日期格式，默认为年-月-日
	 */
	format : 'Y-m-d',
	/**
	 * 默认不允许为空
	 */
	allowBlank : false,
	/**
	 * @return 返回默认为Y-m-d格式的日期数据
	 */
	getFormatValue : function()
	{
		return this.getValue().format("Y-m-d");
    }
});

Ext.reg('MyExtdatefield', MyExt.form.DateField);



/**
 * 
 * @class MyExt.form.ImageField
 * @extends Ext.form.Field
 * 图片控件
 */
MyExt.form.ImageField = Ext.extend(Ext.form.Field, {
	
	initComponent : function()
	{
		MyExt.form.ImageField.superclass.initComponent.call(this);
		
		this.autoCreate = {
			tag : 'input', 
			type : 'image',
			src : this.src||Ext.BLANK_IMAGE_URL
		};
		
		if(this.width){
			this.autoCreate.width = this.width;
		}
		if(this.height){
			this.autoCreate.height = this.height;
		}
		if(this.alt){
			this.autoCreate.alt = this.alt;
		}
		if(this.title){
			this.autoCreate.title = this.title;
		}
	},
	
	getSrc : function()
	{
		return this.el.dom.src;
	},
	
	setSrc : function(src)
	{
		this.el.dom.src = src;
	}
});

Ext.reg('imagefield', MyExt.form.ImageField);


/**
 * 
 * @class MyExt.Window
 * @extends Ext.Window
 */
MyExt.Window = Ext.extend(Ext.Window, {
	/**
	 * 自动适应布局
	 */
	layout : 'fit',
	plain: true,
	/**
	 * 子元素隐藏边框
	 */
	border : false,
	/**
	 * 显示时创建遮蔽层，覆盖下面所有元素
	 */
	modal : true,
	/**
	 * 窗口是否可以最大化，默认可以最大化
	 */
	maximizable : false,
	/**
	 * 窗口是否可以收缩，默认不可以收缩
	 */
	collapsible : false,
	/**
	 * 是否可以调整窗口大小，默认为不能调整
	 */
	resizable : false,
	/**
	 * 窗口是否可以关闭，默认可以关闭
	 */
	closable : true,
	/**
	 * 窗口移动时是否可以移动出父容器外，默认为不可以
	 */
	constrain : true,
	bodyStyle : 'padding:5px;',
	//maximized : true,
	//autoScroll : true,
	/**
	 * 底部按钮默认为居中
	 */
	buttonAlign : 'center',
	/**
	 * 窗口关闭时的处理方式，默认为隐藏 
	 */
	closeAction : 'hide'
});


MyExt.ColumnItem = Ext.extend(Ext.Panel, {
	
    anchor : '100%',
    frame : true,
    layout: 'fit'
//    cls : 'MyExt-column-item'
});

Ext.reg('columnitem', MyExt.ColumnItem);


MyExt.ColumnContainer = Ext.extend(Ext.Container, {
	
    layout : 'anchor',
    defaultType : 'columnitem',
    defaults : {cls : 'MyExt-column-item'},
    cls : 'MyExt-column'
});

Ext.reg('columncontainer', MyExt.ColumnContainer);


/**
 * 自定义VTYPE
 */
Ext.apply(Ext.form.VTypes, {
	
	'password' : function(value, field)
	{
	  if(field.compareTo)
	  {
	      var pwd = Ext.get(field.compareTo);
	      return (value == pwd.getValue());
	  }
	  
	  return true;
	},
	/**
	 * 
	 * 两次输入密码是否相同对比校验
	 * 需要对比的组件需定义compareTo属性，值为所参照的密码输入组件的ID
	 * compareTo : id
	 * 
	 */
	'passwordText' : 'Must be the same',
	
	'passwordMask' : /[a-zA-Z0-9]/,
	
	/**
	 * 校验输入的ID地址是否正确
	 * 包括输入校验只允许输入0-9和小数点.
	 * 包括输入后校验，验证是否为合法的ip地址
	 */
	'IPAddress' : function(value)
    {
    	var ipReg = /^([1-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(([0-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){2}([1-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$/;
        return ipReg.test(value);
    },
    
    'IPAddressText' : '请输入一个正确的ip地址',
    
    'IPAddressMask' : /[\d\.]/,
    
	/**
	 * 校验输入的时间是否正确
	 * 包括输入校验只允许输入0-9、空格、amp
	 * 包括输入后校验，验证是否为合法的时间格式12:34 PM
	 */
	'time' : function(value, field)
	{
		var timeReg = /^([1-9]|1[0-9]):([0-5][0-9])(\s[a|p]m)$/i;
	    return timeReg.test(value);
	},
	
	'timeText' : 'Not a valid time.  Must be in the format "12:34 PM".',
	
	'timeMask' : /[\d\s:amp]/i,
	
	/**
	 * 校验输入的年龄是否正确
	 * 包括输入校验只允许输入0-9的数字
	 * 包括输入后校验，验证是否为合法的年龄，必须大于0岁小于200岁
	 */
	'age' : function(value)
	{  
	     var _age = value;
	     
	     if(_age < 200)
	     {
	     	return true;
	     }
	     else
	     {
		    return false;
	     }
	 }, 
	   
	'ageText' : 'Not a valid age.Must be in the format 23',
	   
	'ageMask' : /[0-9]/,
	
	/**
	 * 校验输入的邮政编码是否正确
	 * 包括输入校验只允许输入0-9的数字
	 * 包括输入后校验，验证是否为合法的邮政编码，226001
	 */
	'postcode' : function(_v)
	{  
		return /^[1-9]\d{5}$/.test(_v);  
	},
	
	'postcodeText' : 'Not a valid postcode.Must be in the format 226001',  
	
	'postcodeMask' : /[0-9]/,
	
	/**
	 * 校验输入的电话号码是否正确
	 * 包括输入校验只允许输入0-9的数字和-
	 * 包括输入后校验，验证是否为合法的电话号码，0513-89500414,051389500414,89500414 
	 */
	'telephone' : function(_v) 
	{  
		return /(^\d{3}\-\d{7,8}$)|(^\d{4}\-\d{7,8}$)|(^\d{3}\d{7,8}$)|(^\d{4}\d{7,8}$)|(^\d{7,8}$)/.test(_v);  
	},
	
	'telephoneText' : 'Not a valid telephone.Must be in the format 0513-89500414,051389500414,89500414',  
	
	'telephoneMask' : /[0-9\-]/,
	
	/**
	 * 校验输入的手机号码是否正确
	 * 包括输入校验只允许输入0-9的数字
	 * 包括输入后校验，验证是否为合法的手机号码，13485135075 
	 */
	'mobile' : function(_v)
	{  
	    return /^1[358]\d{9}$/.test(_v);  
	},
	
	'mobileText' : 'Not a valid mobile.Must be in the format 13485135075',  
	
	'mobileMask' : /[0-9]/,
	
	/**
	 * 校验输入的身份证号码是否正确
	 * 包括输入校验只允许输入0-9的数字
	 * 包括输入后校验，验证是否为合法的身份证号码，110101198002160012,11010119800216001X 
	 */
	'idcard' : function(value)
	{
		var idReg = /^\d{15}$|^\d{17}(\d{1}|[xX])$/;
		return idReg.test(value);
	},
	
	'idcardText' : 'Not a valid idcard.Must be in the format 110101198002160012,11010119800216001X',
	'idcardMask' : /[0-9xX]/,
	
	/**
	 * 校验输入的字符是否为汉字
	 * 包括输入校验只允许输入汉字
	 * 包括输入后校验，验证是否为汉字  
	 */
	'chinese' : function(value)
	{
		var chineseReg = /^[\u4e00-\u9fa5]*$/g;
		return chineseReg.test(value);
	},
	
	'chineseText' : 'Not a chinese',
	
	'chineseMask' : /^[\u4e00-\u9fa5]/,
	
	/**
	 * 日期范围校验
	 * 开始日期必须小于等于结束日期，结束日期必须大于等于开始日期
	 * 开始日期组件需设置属性endDateField:'结束日期id',
	 * 结束日期组件需设置属性startDateField:'开始日期id'，
	 * 如果需要设置开始日期与结束日期最大间隔，请设置开始日期组件属性dateInterval: X(月数)
	 */
	'daterange' : function(val, field)
	{
		var date = field.parseDate(val);

		if (!date){
			return;
		}
		
		
		if (field.startDateField && (!this.dateRangeMax || (date.getTime() != this.dateRangeMax.getTime())))
		{
			var start = Ext.getCmp(field.startDateField);
			start.setMaxValue(date);
			start.validate();
			this.dateRangeMax = date;
		}
		else if(field.endDateField && (!this.dateRangeMin || (date.getTime() != this.dateRangeMin.getTime())))
		{
			var end = Ext.getCmp(field.endDateField);
			end.setMinValue(date);
			if(field.dateInterval){
				end.setMaxValue(date.add(Date.DAY, field.dateInterval));
			}
			end.validate();
			this.dateRangeMin = date;
		}
		return true;
	},
	
	/**
	 * 文件类型下拉框与文件上传框联动校验，判断文件类型是否正确
	 * 文件类型下拉框需要配置fileField: '文件上传框id'
	 * 文件上传框需要配置typeField: '文件类型下拉框id'
	 */
	'filetype' : function(val, field)
	{
		
		if(field.typeField)
		{
			var selectedType = Ext.getCmp(field.typeField).getValue();
			if(selectedType != "")
			{
				var type = val.substring(val.lastIndexOf(".")+1)
				if(selectedType.indexOf(",") != -1)
				{
					var types = selectedType.split(",");
					for(var i=0;i<types.length;i++)
					{
						if(type == types[i])
						{
							return true;
						}
					}
					this.filetypeText = "文件类型不正确，应为"+Ext.getCmp(field.typeField).getRawValue();
					return false;
				}
				else
				{
					if(type != selectedType)
					{
						this.filetypeText = "文件类型不正确，应为"+Ext.getCmp(field.typeField).getRawValue();
						return false;
					}
				}
			}
		}
		else if(field.fileField)
		{
			var fileField = Ext.getCmp(field.fileField)
			if(fileField.getValue() != "")
			{
				fileField.clearInvalid();
				
				var selectedType = field.store.getAt(field.store.findExact(field.displayField,val)).get(field.valueField);
				if(selectedType != "")
				{
					var type = fileField.getValue().substring(fileField.getValue().lastIndexOf(".")+1)
					if(selectedType.indexOf(",") != -1)
					{
						var types = selectedType.split(",");
						for(var i=0;i<types.length;i++)
						{
							if(type == types[i])
							{
								return true;
							}
						}
						fileField.markInvalid("文件类型不正确，应为"+field.getRawValue());
					}
					else
					{
						if(type != selectedType)
						{
							fileField.markInvalid("文件类型不正确，应为"+field.getRawValue());
						}
					}
				}
			}
		}
		return true;
	},
	
	/**
	 * 校验输入的字符是否为MAC地址
	 * 包括输入校验只允许输0-9,a-f,A-F
	 * 包括输入后校验，验证是否为合法的MAC地址  
	 */
	'mac' : function(value)
	{
		var macReg = /^([0-9a-fA-F]{2})((-[0-9a-fA-F]{2}){5})$/g;
		return macReg.test(value);
	},
	
	'macText' : 'Not a MAC address',
	
	'macMask' : /[0-9a-fA-F-]/,
	/**
	 * 校验输入的字符是否为MAC地址
	 * 包括输入校验只允许输0-9,a-f,A-F
	 * 包括输入后校验，验证是否为合法的MAC地址  
	 */
	'num' : function(value)
	{
		var numReg = /^[0-9]*$/g;
		return numReg.test(value);
	},
	
	'numText' : 'Not a number',
	
	
	'4num' : function(value)
	{
		//var numReg = /^[123456789](\d{0,3})$/;
		var numReg = /^\d{0,4}$/;
		
		return numReg.test(value);
	},
	
	'4numText' : '请输入有效的1-4位数字',
	
	
	'numMask' : /[0-9]/,
	/**
	 * 校验输入的字符是否为数字、字母、下划线并且第一个字符不能为数字
	 * 包括输入校验只允许输入数字、字母、下划线
	 * 包括输入后校验，验证是否为数字、字母、下划线  
	 */
	'username' : function(value)
	{
		var usernameReg = /^[a-zA-Z_]{1}\w*$/g;
		return usernameReg.test(value);
	},
	
	'usernameText' : 'Not a valid username',
	
	'usernameMask' : /\w/,
	/**
	 * 校验输入的字符是否为数字、字母、下划线、汉字并且第一个字符不能为数字
	 * 包括输入校验只允许输入数字、字母、下划线、汉字
	 * 包括输入后校验，验证是否为数字、字母、下划线、汉字
	 */
	'rolename' : function(value)
	{
		var rolenameReg = /^[a-zA-Z\u4e00-\u9fa5_]{1}[\w\u4e00-\u9fa5]*$/g;
		return rolenameReg.test(value);
	},
	
	'rolenameText' : 'Not a valid rolename',
	
	'rolenameMask' : /[\w]/

});



/**
 * 收缩左侧树形菜单时，对右侧主内容区域进行resize操作
 * @param container 需要resize的容器对象
 */
MyExt.util.Resize = function(container) {
	alert(111);
	var isScroll = Ext.getBody().isScrollable();
	
	window.onresize = function()
	{
		if(Ext.isIE)
		{
			if(!isScroll)
			{
				container.setSize(Ext.getBody().getComputedWidth());
			}
			else
			{
				container.setSize(Ext.getBody().getComputedWidth()-Ext.getScrollBarWidth());
			}
				
		}
		else
		{
			if(!isScroll)
			{
				container.setSize(!Ext.getBody().isScrollable()?Ext.getBody().getComputedWidth():Ext.getBody().getComputedWidth()+17);
			}
			else
			{
				container.setSize(Ext.getBody().getComputedWidth());
			}
		}
	}
	/**
	if(container.getXType() == 'MyExtcontainer')
	{
		window.onresize = function()
		{
			container.setSize(Ext.getBody().getViewSize().width);
		}
	}
	else if(container.getXType() == 'portal')
	{
		window.onresize = function()
		{
			if(Ext.isIE)
			{
				container.setSize(Ext.getBody().getComputedWidth());
			}
			else
			{
				
				//存在纵向滚动条时
				 
				if(Ext.getBody().dom.scrollHeight > Ext.getBody().dom.clientHeight)
				{
					container.setSize(Ext.getBody().getComputedWidth()+17);
				}
				else
				{
					container.setSize(Ext.getBody().getComputedWidth());
				}
			}
		}
	}
	*/
};

MyExt.util.ResizeGrid = function(grid,id){
  	Ext.EventManager.onWindowResize(function(width,height){
		//grid.setWidth(0);
		setTimeout(function(){
				grid.setSize(Ext.get(id).getComputedWidth(),Ext.get(id).getComputedHeight());
		},100)
		
	})
}
  
  
   	//=========================================================================
	//     导出当前表封装的方法
	//=========================================================================
MyExt.util.exportCurentTable = function(grid, req_url,title) {
		var gcm = grid.getColumnModel();
   		
   		var totalcount = gcm.getColumnCount();
		var dataArray = [];
		var columnDataIndexArray = [];
		data = [];
		for(var i = 0;i < totalcount;i++){
				if(gcm.getColumnById(i)!=null){
					dataArray.push(gcm.getColumnHeader(i));		
					columnDataIndexArray.push(gcm.getDataIndex(i));		
				}													
		}
		data.push(dataArray);
		data.push(columnDataIndexArray);

		var date = new Date();		
		var time = date.getFullYear() + "-" + (date.getMonth()+1) + "-" + date.getDate();
		var exportFileName = title + time;
		var exportData = Ext.encode(data)
		
		document.ExportForm.action = req_url;
		document.ExportForm.exportData.value = exportData;
		document.ExportForm.exportFileName.value = exportFileName;
		document.ExportForm.submit();
		
}  

